home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / optivc16 / mestd.h < prev    next >
C/C++ Source or Header  |  1999-03-06  |  69KB  |  1,333 lines
  1. /*  MEstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "extended"
  5.   (extended-precision real numbers)
  6.  
  7.   Copyright (c) 1996-1999 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MESTD_H )
  12. #define __MESTD_H
  13. #if !defined( __MATLIB_H )
  14. #include <MatLib.h>
  15. #endif
  16. #if !defined( __VESTD_H )
  17. #include <VEstd.h>
  18. #endif
  19. #if !defined( __VEMATH_H )
  20. #include <VEmath.h>
  21. #endif
  22.  
  23. #ifdef __BORLANDC__
  24.        /* the following ca. 1000 lines are only for Borland C++,
  25.           as neither Visual C++ nor Optima++ support 80-bit reals */
  26. #ifdef __cplusplus
  27. extern "C" {
  28. #endif
  29.  
  30. /*************   Dynamic Generation of Matrices   ************************/
  31.  
  32. eMatrix __vf  ME_matrix(  unsigned ht, unsigned len );
  33. eMatrix __vf  ME_matrix0( unsigned ht, unsigned len );
  34.     /*  notice that, in the memory model HUGE,
  35.         neither len nor ht may exceed 3275             */
  36.  
  37. /***************************************************************************
  38.  *  The following definitions ensure compatibility between dynamically     *
  39.  *  and statically allocated matrices. The definitions are somewhat        *
  40.  *  cumbersome, but the result for you is that you need not care about     *
  41.  *  the differences between the two types.                                 *
  42.  *  (Internally, the address of the first element of any matrix is needed; *
  43.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  44.  *  but yields in either case the correct address to be passed to the      *
  45.  *  function you wish to call.)                                            *
  46.  *  Only in the rare case that you need to pass the address of one of      *
  47.  *  these functions as an argument to another function, you have to use    *
  48.  *  the actual run-time functions defined further below. Be careful with   *
  49.  *  this: future development of compilers may allow us to avoid this un-   *
  50.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  51.  *  use these run-time names.                                              *
  52.  ***************************************************************************/
  53.  
  54.  
  55. /***  Addressing single elements of dynamically allocated matrices: ******
  56.      These two functions are for compatibility with Pascal
  57.      (where elements of dynamically allocated matrices are not directly
  58.      accessible), and for getting around the pointer arithmetics bug in
  59.      some versions of Borland C++.                                         */
  60.  
  61. #define ME_Pelement( MA, ht, len, m, n ) MEPelement( MA[0], ht, len, m, n )
  62.                      /* returns a pointer to MA[m][n]. */
  63. #define ME_element( MA, ht, len, m, n ) *MEPelement( MA[0], ht, len, m, n )
  64.                      /* dereferenced pointer */
  65.  
  66.  /****************  Initialization  ***************************************
  67.  
  68.     To initialize all elements of a matrix with the same value,
  69.     or to perform arithmetic operations on all elements simultaneously,
  70.     refer to the functions of VectorLib, declared in <VEstd.h>, <VEmath.h>.
  71.     In order to use the VectorLib functions, utilize the feature that
  72.     the whole matrix occupies one contiguous area in memory: pass the
  73.     address of the first row to the desired vector function, the size
  74.     of the "vector" being ht * len.
  75.     For example, initialize all elements of the matrix MA with 1.0
  76.     (this is *NOT* the identity matrix)  by calling
  77.         VE_equ1( MA[0], ht * len );
  78. */
  79.  
  80. #define ME_equ0( MA, ht, len )            VE_equ0( MA[0], ((ui)ht)*len )
  81. #define ME_equ1( MA, len )                MEequ1( MA[0], len )
  82.                        /* this is the identity matrix */
  83. #define ME_outerprod( MA, X, Y, ht, len ) MEouterprod( MA[0], X, Y, ht, len )
  84.                        /* sizX=ht, sizY=len */
  85. #define ME_Row_equC( MA, ht, len, iRow, C ) \
  86.                                         MERow_equC( MA[0], ht, len, iRow, C )
  87. #define ME_Col_equC( MA, ht, len, iCol, C ) \
  88.                                         MECol_equC( MA[0], ht, len, iCol, C )
  89. #define ME_Dia_equC( MA, len, C )       MEDia_equC( MA[0], len, C )
  90.  
  91. #define ME_Row_equV( MA, ht, len, iRow, X ) \
  92.                                         MERow_equV( MA[0], ht, len, iRow, X )
  93. #define ME_Col_equV( MA, ht, len, iCol, X ) \
  94.                                         MECol_equV( MA[0], ht, len, iCol, X )
  95. #define ME_Dia_equV( MA, len, X )       MEDia_equV( MA[0], len, X )
  96.  
  97. #define ME_equM( MB, MA, ht, len )  VE_equV( MB[0], MA[0], (ui)(ht)*(len) )
  98.  
  99. #define ME_UequL( MA, len ) MEUequL( MA[0], len )
  100. #define ME_LequU( MA, len ) MELequU( MA[0], len )
  101.          /* copy lower-diagonal elements into upper-diagonal
  102.            (or vice versa) by index-reflection, so as to
  103.            get a symmetric matrix    */
  104.  
  105.             /* data-type conversions:  */
  106. #define M_EtoF( MF, ME, ht, len ) V_EtoF( MF[0], ME[0], ((ui)ht)*len )
  107. #define M_FtoE( ME, MF, ht, len ) V_FtoE( ME[0], MF[0], ((ui)ht)*len )
  108. #define M_EtoD( MD, ME, ht, len ) V_EtoD( MD[0], ME[0], ((ui)ht)*len )
  109. #define M_DtoE( ME, MD, ht, len ) V_DtoE( ME[0], MD[0], ((ui)ht)*len )
  110.  
  111.             /* suitable windows for ME_spectrum: */
  112. #define ME_Hanning( MA, ht, len )  MEHanning( MA[0], ht, len )
  113. #define ME_Parzen( MA, ht, len )   MEParzen( MA[0], ht, len )
  114. #define ME_Welch( MA, ht, len )    MEWelch( MA[0], ht, len )
  115.  
  116.  
  117. /********  Extracting a submatrix and copying a submatrix back  *********/
  118.  
  119. #define ME_submatrix( MSub, subHt, subLen, \
  120.                       MSrce, srceHt, srceLen, \
  121.                       firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  122.                MEsubmatrix(  MSub[0], subHt, subLen, \
  123.                              MSrce[0], srceHt, srceLen, \
  124.                              firstRowInCol, sampInCol, firstColInRow, sampInRow )
  125.  
  126. #define ME_submatrix_equM( MDest, destHt, destLen, \
  127.                            firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  128.                            MSrce, srceHt, srceLen ) \
  129.                MEsubmatrix_equM(  MDest[0], destHt, destLen, \
  130.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  131.                              MSrce[0], srceHt, srceLen )
  132.  
  133. /*****   Extracting a single row or a single column or the diagonal  ******
  134.  *       and storing it into a vector                                     */
  135.  
  136. #define ME_Row_extract( Y, MA, ht, len, iRow ) \
  137.                                      MERow_extract( Y, MA[0], ht, len, iRow )
  138. #define ME_Col_extract( Y, MA, ht, len, iCol ) \
  139.                                      MECol_extract( Y, MA[0], ht, len, iCol )
  140. #define ME_Dia_extract( Y, MA, len ) MEDia_extract( Y, MA[0], len )
  141.  
  142.  
  143. /*****************    Basic arithmetic operations *********************
  144.                       performed on one single row,
  145.                       or one single column of any matrix,
  146.                       or on the diagonal of a square matrix
  147.  
  148.     Note: In contrast to the analogous VectorLib functions, the operations
  149.     are performed in-place, i.e. the input matrix itself is changed  */
  150.  
  151. #define ME_Row_addC( MA, ht, len, iRow, C ) \
  152.                                      MERow_addC( MA[0], ht, len, iRow, C )
  153. #define ME_Col_addC( MA, ht, len, iCol, C ) \
  154.                                      MECol_addC( MA[0], ht, len, iCol, C )
  155. #define ME_Dia_addC( MA, len, C )    MEDia_addC( MA[0], len, C )
  156.  
  157. #define ME_Row_addV( MA, ht, len, iRow, X ) \
  158.                                      MERow_addV( MA[0], ht, len, iRow, X )
  159. #define ME_Col_addV( MA, ht, len, iCol, X ) \
  160.                                      MECol_addV( MA[0], ht, len, iCol, X )
  161. #define ME_Dia_addV( MA, len, X )    MEDia_addV( MA[0], len, X )
  162.  
  163. #define ME_Row_subC( MA, ht, len, iRow, C ) \
  164.                                      MERow_addC( MA[0], ht, len, iRow, (-C) )
  165. #define ME_Col_subC( MA, ht, len, iCol, C ) \
  166.                                      MECol_addC( MA[0], ht, len, iCol, (-C) )
  167. #define ME_Dia_subC( MA, len, C )    MEDia_addC( MA[0], len, (-C) )
  168.  
  169. #define ME_Row_subV( MA, ht, len, iRow, X ) \
  170.                                      MERow_subV( MA[0], ht, len, iRow, X )
  171. #define ME_Col_subV( MA, ht, len, iCol, X ) \
  172.                                      MECol_subV( MA[0], ht, len, iCol, X )
  173. #define ME_Dia_subV( MA, len, X )    MEDia_subV( MA[0], len, X )
  174.  
  175. #define ME_Row_subrC( MA, ht, len, iRow, C ) \
  176.                                      MERow_subrC( MA[0], ht, len, iRow, C )
  177. #define ME_Col_subrC( MA, ht, len, iCol, C ) \
  178.                                      MECol_subrC( MA[0], ht, len, iCol, C )
  179. #define ME_Dia_subrC( MA, len, C )   MEDia_subrC( MA[0], len, C )
  180.  
  181. #define ME_Row_subrV( MA, ht, len, iRow, X ) \
  182.                                      MERow_subrV( MA[0], ht, len, iRow, X )
  183. #define ME_Col_subrV( MA, ht, len, iCol, X ) \
  184.                                      MECol_subrV( MA[0], ht, len, iCol, X )
  185. #define ME_Dia_subrV( MA, len, X )   MEDia_subrV( MA[0], len, X )
  186.  
  187. #define ME_Row_mulC( MA, ht, len, iRow, C ) \
  188.                                      MERow_mulC( MA[0], ht, len, iRow, C )
  189. #define ME_Col_mulC( MA, ht, len, iCol, C ) \
  190.                                      MECol_mulC( MA[0], ht, len, iCol, C )
  191. #define ME_Dia_mulC( MA, len, C )    MEDia_mulC( MA[0], len, C )
  192.  
  193. #define ME_Row_mulV( MA, ht, len, iRow, X ) \
  194.                                      MERow_mulV( MA[0], ht, len, iRow, X )
  195. #define ME_Col_mulV( MA, ht, len, iCol, X ) \
  196.                                      MECol_mulV( MA[0], ht, len, iCol, X )
  197. #define ME_Dia_mulV( MA, len, X )    MEDia_mulV( MA[0], len, X )
  198.  
  199. #define ME_Row_divC( MA, ht, len, iRow, C ) \
  200.                                      MERow_divC( MA[0], ht, len, iRow, C )
  201. #define ME_Col_divC( MA, ht, len, iCol, C ) \
  202.                                      MECol_divC( MA[0], ht, len, iCol, C )
  203. #define ME_Dia_divC( MA, len, C )    MEDia_divC( MA[0], len, C )
  204.  
  205. #define ME_Row_divV( MA, ht, len, iRow, X ) \
  206.                                       MERow_divV( MA[0], ht, len, iRow, X )
  207. #define ME_Col_divV( MA, ht, len, iCol, X ) \
  208.                                       MECol_divV( MA[0], ht, len, iCol, X )
  209. #define ME_Dia_divV( MA, len, X )     MEDia_divV( MA[0], len, X )
  210.  
  211. #define ME_Row_divrC( MA, ht, len, iRow, C ) \
  212.                                       MERow_divrC( MA[0], ht, len, iRow, C )
  213. #define ME_Col_divrC( MA, ht, len, iCol, C ) \
  214.                                       MECol_divrC( MA[0], ht, len, iCol, C )
  215. #define ME_Dia_divrC( MA, len, C )    MEDia_divrC( MA[0], len, C )
  216.  
  217. #define ME_Row_divrV( MA, ht, len, iRow, X ) \
  218.                                       MERow_divrV( MA[0], ht, len, iRow, X )
  219. #define ME_Col_divrV( MA, ht, len, iCol, X ) \
  220.                                       MECol_divrV( MA[0], ht, len, iCol, X )
  221. #define ME_Dia_divrV( MA, len, X )    MEDia_divrV( MA[0], len, X )
  222.  
  223.  
  224. /******  One-dimensional vector operations **********************
  225.          performed along all rows or all columns simultaneously,
  226.          or along the diagonal of a square matrix                */
  227.  
  228. #define ME_Rows_max( Y, MA, ht, len )     MERows_max( Y, MA[0], ht, len )
  229. #define ME_Cols_max( Y, MA, ht, len )     MECols_max( Y, MA[0], ht, len )
  230. #define ME_Dia_max(  MA, len )            MEDia_max(  MA[0], len )
  231. #define ME_Rows_min( Y, MA, ht, len )     MERows_min( Y, MA[0], ht, len )
  232. #define ME_Cols_min( Y, MA, ht, len )     MECols_min( Y, MA[0], ht, len )
  233. #define ME_Dia_min(  MA, len )            MEDia_min(  MA[0], len )
  234.  
  235. #define ME_Rows_absmax( Y, MA, ht, len )  MERows_absmax( Y, MA[0], ht, len )
  236. #define ME_Cols_absmax( Y, MA, ht, len )  MECols_absmax( Y, MA[0], ht, len )
  237. #define ME_Dia_absmax(  MA, len )         MEDia_absmax(  MA[0], len )
  238. #define ME_Rows_absmin( Y, MA, ht, len )  MERows_absmin( Y, MA[0], ht, len )
  239. #define ME_Cols_absmin( Y, MA, ht, len )  MECols_absmin( Y, MA[0], ht, len )
  240. #define ME_Dia_absmin(  MA, len )         MEDia_absmin(  MA[0], len )
  241.  
  242. #define ME_Rows_sum( Y, MA, ht, len )     MERows_sum( Y, MA[0], ht, len )
  243. #define ME_Cols_sum( Y, MA, ht, len )     MECols_sum( Y, MA[0], ht, len )
  244. #define ME_Dia_sum(  MA, len )            MEDia_sum(  MA[0], len )
  245. #define ME_Rows_prod( Y, MA, ht, len )    MERows_prod( Y, MA[0], ht, len )
  246. #define ME_Cols_prod( Y, MA, ht, len )    MECols_prod( Y, MA[0], ht, len )
  247. #define ME_Dia_prod(  MA, len )           MEDia_prod(  MA[0], len )
  248.  
  249. #define ME_Rows_runsum( MA, ht, len )     MERows_runsum( MA[0], ht, len )
  250. #define ME_Cols_runsum( MA, ht, len )     MECols_runsum( MA[0], ht, len )
  251. #define ME_Rows_runprod( MA, ht, len )    MERows_runprod( MA[0], ht, len )
  252. #define ME_Cols_runprod( MA, ht, len )    MECols_runprod( MA[0], ht, len )
  253.  
  254. #define ME_Rows_rotate( MA, ht, len, pos) MERows_rotate( MA[0], ht, len, pos )
  255. #define ME_Cols_rotate( MA, ht, len, pos) MECols_rotate( MA[0], ht, len, pos )
  256. #define ME_Rows_reflect( MA, ht, len )    MERows_reflect( MA[0], ht, len )
  257. #define ME_Cols_reflect( MA, ht, len )    MECols_reflect( MA[0], ht, len )
  258.  
  259. /********  Operations involving two rows or two colums of one matrix  *****/
  260.  
  261. #define ME_Rows_exchange( MA, ht, len, row1, row2 ) \
  262.                              MERows_exchange( MA[0], ht, len, row1, row2 )
  263. #define ME_Cols_exchange( MA, ht, len, col1, col2 ) \
  264.                              MECols_exchange( MA[0], ht, len, col1, col2 )
  265.  
  266. #define ME_Rows_add( MA, ht, len, destRow, srceRow ) \
  267.                              MERows_add( MA[0], ht, len, destRow, srceRow )
  268. #define ME_Cols_add( MA, ht, len, destCol, srceCol ) \
  269.                              MECols_add( MA[0], ht, len, destCol, srceCol )
  270.                          /* dest[i] += source[i]  */
  271.  
  272. #define ME_Rows_sub( MA, ht, len, destRow, srceRow ) \
  273.                              MERows_sub( MA[0], ht, len, destRow, srceRow )
  274. #define ME_Cols_sub( MA, ht, len, destCol, srceCol ) \
  275.                              MECols_sub( MA[0], ht, len, destCol, srceCol )
  276.                          /* dest[i] -= source[i]  */
  277.  
  278. #define ME_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  279.                           MERows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  280. #define ME_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  281.                           MECols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  282.                          /* dest[i] += C * source[i]  */
  283.  
  284. #define ME_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  285.             MERows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  286. #define ME_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  287.             MECols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  288.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  289.  
  290.  
  291. /*************************  Transposing a matrix **********************/
  292.  
  293. #define ME_transpose( MTr, MA, htTr, lenTr ) \
  294.              MEtranspose( MTr[0], MA[0], htTr, lenTr )
  295.        /*  dimensions htTr, lenTr are those of the transposed matrix,
  296.            not of the original!                */
  297.  
  298.  
  299. /************************ Matrix Arithmetics *************************/
  300.  
  301. #define ME_addM( MC, MA, MB, htA, lenA ) \
  302.                  VE_addV( MC[0], MA[0], MB[0], ((ui)htA)*lenA )
  303. #define ME_subM( MC, MA, MB, htA, lenA ) \
  304.                  VE_subV( MC[0], MA[0], MB[0], ((ui)htA)*lenA )
  305. #define ME_mulC( MB, MA, htA, lenA, C ) \
  306.                  VE_mulC( MB[0], MA[0], ((ui)htA)*lenA, C )
  307. #define ME_divC( MB, MA, htA, lenA, C ) \
  308.                  VE_divC( MB[0], MA[0], ((ui)htA)*lenA, C )
  309. #define MEs_addM( MC, MA, MB, htA, lenA, C ) \
  310.                  VEs_addV( MC[0], MA[0], MB[0], ((ui)htA)*lenA, C )
  311. #define MEs_subM( MC, MA, MB, htA, lenA, C ) \
  312.                  VEs_subV( MC[0], MA[0], MB[0], ((ui)htA)*lenA, C )
  313. #define ME_lincomb( MC, MA, MB, htA, lenA, CA, CB ) \
  314.                  VE_lincomb( MC[0], MA[0], MB[0], ((ui)htA)*lenA, CA, CB )
  315.  
  316. #define ME_mulV( Y, MA, X, htA, lenA ) \
  317.                     MEmulV( Y, MA[0], X, htA, lenA )
  318.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  319.                               both X and Y are column-vectors    */
  320. #define VE_mulM( Y, X, MA, sizX, lenA ) \
  321.                     VEmulM( Y, X, MA[0], sizX, lenA )
  322.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  323.                              both X and Y are row-vectors.
  324.                              Mind the prefix: VE_ (not ME_)    */
  325. #define ME_mulM( MC, MA, MB, htA, lenA, lenB ) \
  326.                     MEmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  327.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  328.  
  329.  
  330. /*************************  Linear Algebra    *****************************/
  331.  
  332.    /*  The standard treatment of linear systems is based
  333.        on LUD (matrix decomposition into Upper-triangular
  334.        and Lower-triangular components). The result of the
  335.        decomposition step is used for further operations.  */
  336.  
  337. #define ME_LUdecompose( MLU, Ind, MA, len ) \
  338.                     MELUdecompose( MLU[0], Ind, MA[0], len )
  339.             /* returns "permut" = ±1 which is needed for ME_LUdet.
  340.                for singularities not cured by editing, permut is 0  */
  341. int     __vf ME_LUDresult( void );
  342.     /* returns 0, if ME_LUdecompose was successful;
  343.        returns 1, if MA was (nearly) singular in ME_LUdecompose.   */
  344. void       __vf ME_LUDsetEdit( extended Thresh );
  345. extended   __vf ME_LUDgetEdit( void );
  346.      /*  Editing threshold valid for ME_LUdecompose;
  347.          may be used to cure singularities           */
  348.  
  349. #define ME_LUsolve( X, MLU, B, Ind, len ) \
  350.                     MELUsolve( X, MLU[0], B, Ind, len )
  351. #define ME_LUinv( MInv, MLU, Ind, len ) \
  352.                     MELUinv( MInv[0], MLU[0], Ind, len )
  353. #define ME_LUdet( MLU, len, permut )  MELUdet( MLU[0], len, permut )
  354. #define ME_LUimprove( X, B, MA, MLU, Ind, len ) \
  355.                       MELUimprove( X, B, MA[0], MLU[0], Ind, len )
  356.  
  357.     /****  Special treatment of over- or under-determined
  358.            linear systems, i.e. of matrices with len != ht
  359.            and of singular matrices:
  360.            SVD (Singular Value Decomposition)       ****/
  361.  
  362. #define ME_SVdecompose( MU, MV, W, MA, htA, lenA ) \
  363.                     MESVdecompose( MU[0], MV[0], W, MA[0], htA, lenA )
  364.             /*  sizB = htA,  sizX = sizW = htV = lenV = lenA  */
  365. #define ME_SVsolve( X, MU, MV, W, B, htU, lenU ) \
  366.                     MESVsolve( X, MU[0], MV[0], W, B, htU, lenU )
  367.             /*  lenU = lenA,  htU = max( lenA, htA ) as fed into
  368.                 MD_SVdecompose   */
  369. #define ME_SVimprove( X, B, MA, MU, MV, W, htA, lenA ) \
  370.                     MESVimprove( X, B, MA[0], MU[0], MV[0], W, htA, lenA )
  371. void    __vf ME_SVDsetEdit( extended Thresh );
  372. extended   __vf ME_SVDgetEdit( void );
  373.     /* Override of the standard values for editing threshholds
  374.        in ME_SVsolve. Calling ME_setEdit with Thresh=0.0 means
  375.        that you do the necessary editing of W yourself
  376.        before calling MD_SVsolve                           */
  377.  
  378.  /*****  "Easy-to-use" versions of the matrix functions
  379.           using LUD or SVD.
  380.           They allocate their own working space and rely
  381.           on your setting of the editing threshold. In
  382.           case of memory stress, you might better use the
  383.           two-step methods declared above.            ***/
  384. #define ME_solve( X, MA, B, len ) \
  385.                     MEsolve( X, MA[0], B, len )
  386. #define ME_inv( MInv, MA, len ) \
  387.                     MEinv( MInv[0], MA[0], len )
  388. #define ME_det(  MA, len ) \
  389.                     MEdet( MA[0], len )
  390. #define ME_solveBySVD( X, MA, B, ht, len ) \
  391.                     MEsolveBySVD( X, MA[0], B, ht, len )
  392.          /*  sizX = len,  sizB = ht  */
  393. #define ME_safeSolve( X, MA, B, len ) \
  394.                     MEsafeSolve( X, MA[0], B, len )
  395.         /* ME_safeSolve tries first LUD. If that fails, SVD is done.
  396.            X[i] will be 0.0 instead of INF for those i corresponding
  397.            to singularities. If even SVD fails, all X[i] are set to 0.0.
  398.            return value 0: success via LUD; 1: success via SVD; -1: failure */
  399.  
  400.       /*********  Eigenvalues and Eigenvectors  ********/
  401.       /*** only the most frequent case of symmetric real matrices
  402.            is covered here! *********/
  403.  
  404. #define MEsym_eigenvalues( EigV, EigM, MA, len, CalcEigenVec ) \
  405.                     MEs_eigenvalues( EigV, EigM[0], MA[0], len, CalcEigenVec )
  406.                         /*  Eigenvalues are returned in EigV,
  407.                             Eigenvectors are returned as the columns of EigM.
  408.                             CalcEigenVec = 0 means that only eigenvalues
  409.                             are needed; CalcEigenVec != 0 means that
  410.                             also eigenvectors are calculated.
  411.                             Even if eigenvectors are not desired, EigM is
  412.                             needed by the function as working-space. The, on
  413.                             output, it will contain just rubbish.
  414.                             MA may be overwritten by EigM. */
  415.  
  416.  
  417. /***************** Two-Dimensional Fourier-Transform Methods ************/
  418.  
  419. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  420. } // following function cannot be extern "C"
  421. #endif
  422. eComplex  __vf   VE_getRspEdit( void );
  423. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  424. extern "C" {
  425. #endif
  426. void      __vf   VE_setRspEdit( eComplex Trunc );
  427.            /* these are the same functions as used
  428.               in the one-dimensional case */
  429.  
  430. #define MEl_FFT( MY, MX, ht, len, dir )     MElFFT( MY[0], MX[0], ht, len, dir )
  431. #define MEs_FFT( MY, MX, ht, len, dir )     MEsFFT( MY[0], MX[0], ht, len, dir )
  432. #define MEl_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  433.                   MElconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  434. #define MEl_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  435.                   MEldeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  436. #define MEl_filter( MY, MX, MFlt, ht, len ) MElfilter( MY[0], MX[0], MFlt[0], ht, len )
  437. #define MEl_autocorr( MACorr, MX, ht, len ) MElautocorr( MACorr[0], MX[0], ht, len )
  438. #define MEl_xcorr( MXCorr, MX, MY, ht, len) MElxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  439. #define MEl_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  440.               MElspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  441.                 /* htSpec, lenSpec must be 2**n,
  442.                    MSpec must be a (htSpec+1)*(lenSpec+1) matrix!!
  443.                    htX >= n*htSpec,  lenX >= n*lenSpec,
  444.                    htWin = 2*htSpec, lenWin = 2*lenSpec */
  445.  
  446. #define MEs_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  447.                   MEsconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  448. #define MEs_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  449.                   MEsdeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  450. #define MEs_filter( MY, MX, MFlt, ht, len ) MEsfilter( MY[0], MX[0], MFlt[0], ht, len )
  451. #define MEs_autocorr( MACorr, MX, ht, len ) MEsautocorr( MACorr[0], MX[0], ht, len )
  452. #define MEs_xcorr( MXCorr, MX, MY, ht, len) MEsxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  453. #define MEs_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  454.               MEsspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  455.                 /* htSpec, lenSpec must be 2**n,
  456.                    MSpec has [htSpec+1][lenSpec+1] elements (!)
  457.                    htX >= n*htSpec,  lenX >= n*lenSpec,
  458.                    htWin = 2*htSpec, lenWin = 2*lenSpec     */
  459.  
  460. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  461.    #define ME_FFT         MEl_FFT
  462.    #define ME_convolve    MEl_convolve
  463.    #define ME_deconvolve  MEl_deconvolve
  464.    #define ME_filter      MEl_filter
  465.    #define ME_autocorr    MEl_autocorr
  466.    #define ME_xcorr       MEl_xcorr
  467.    #define ME_spectrum    MEl_spectrum
  468. #else
  469.    #define ME_FFT         MEs_FFT
  470.    #define ME_convolve    MEs_convolve
  471.    #define ME_deconvolve  MEs_deconvolve
  472.    #define ME_filter      MEs_filter
  473.    #define ME_autocorr    MEs_autocorr
  474.    #define ME_xcorr       MEs_xcorr
  475.    #define ME_spectrum    MEs_spectrum
  476. #endif
  477.  
  478.  
  479. /************************** Data Fitting *********************************
  480.  
  481.   Notice that some of these functions have the prefix VE_, others ME_.
  482.   This depends on the form in which the data to be fitted are recorded:
  483.   vectors are fitted by the VE_ functions, matrices by the ME_ functions.
  484.   All of these functions employ matrix methods internally. The weighted
  485.   versions return covariances in a matrix "Covar". So they are all
  486.   contained in MatrixLib and declared here.
  487. */
  488.  
  489. void __vf VE_polyfit( eVector A, unsigned deg, eVector X, eVector Y, ui sizex );
  490. #define   VE_polyfitwW( A, Covar, deg, X, Y, InvVar, sizex ) \
  491.           VEpolyfitwW( A, Covar[0], deg, X, Y, InvVar, sizex )
  492.        /* the size of A is deg+1 and Covar has [deg+1][deg+1] elements! */
  493.  
  494. void __vf VE_linfit( eVector A, iVector AStatus, unsigned npars,
  495.                      eVector X, eVector Y, ui sizex,
  496.                      void (*funcs)(eVector BasFuncs, extended x, unsigned nfuncs) );
  497. #define   VE_linfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, funcs ) \
  498.           VElinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, funcs )
  499. #define   ME_linfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, funcs ) \
  500.           MElinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, funcs )
  501. #define   ME_linfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, funcs ) \
  502.           MElinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, funcs )
  503.  
  504. void  __vf VE_setLinfitNeglect( extended Thresh );
  505.                    /* neglect A[i]=0, if significance smaller than Thresh */
  506. extended __vf VE_getLinfitNeglect( void );
  507.  
  508. extended __vf VE_nonlinfit( eVector A, iVector AStatus, unsigned npars,
  509.                     eVector X, eVector Y, ui sizex,
  510.                     void (*modelfunc)(eVector YModel, eVector XModel, ui size),
  511.                     void (*derivatives)(eVector dYdAi,eVector X, ui size, unsigned i) );
  512.             /* returns figure-of-merit of best A. If you don't know the partial
  513.                derivatives with respect to A, call with derivatives=NULL */
  514. #define   VE_nonlinfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv ) \
  515.           VEnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv )
  516. #define   ME_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, modelfunc, deriv ) \
  517.           MEnonlinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, modelfunc, deriv )
  518. #define   ME_nonlinfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, modelfunc, deriv ) \
  519.           MEnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, modelfunc, deriv )
  520.  
  521.         /* If you know some partial derivatives, you may call these functions
  522.            for those parameters for which you do not know them:           */
  523. void     __vf VE_nonlinfit_autoDeriv( eVector dYdAi, eVector X, ui size, unsigned ipar );
  524. void     __vf VE_nonlinfitwW_autoDeriv( eVector dYdAi, eVector X, ui size, unsigned ipar );
  525. void     __vf ME_nonlinfitwW_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned ipar );
  526. void     __vf ME_nonlinfit_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned ipar );
  527.        /* The following functions allow to monitor the progress of
  528.           a nonlinear fitting procedure or to manually stop it:     */
  529. extended __vf VE_nonlinfit_getChi2( void );
  530. extended __vf VE_nonlinfitwW_getChi2( void );
  531. extended __vf ME_nonlinfit_getChi2( void );
  532. extended __vf ME_nonlinfitwW_getChi2( void );
  533. void     __vf VE_nonlinfit_getBestA( eVector ABest );
  534. void     __vf VE_nonlinfitwW_getBestA( eVector ABest );
  535. void     __vf ME_nonlinfit_getBestA( eVector ABest );
  536. void     __vf ME_nonlinfitwW_getBestA( eVector ABest );
  537. unsigned __vf VE_nonlinfit_getTestRun( void );
  538. unsigned __vf VE_nonlinfitwW_getTestRun( void );
  539. unsigned __vf ME_nonlinfit_getTestRun( void );
  540. unsigned __vf ME_nonlinfitwW_getTestRun( void );
  541. unsigned __vf VE_nonlinfit_getTestPar( void );
  542. unsigned __vf VE_nonlinfitwW_getTestPar( void );
  543. unsigned __vf ME_nonlinfit_getTestPar( void );
  544. unsigned __vf ME_nonlinfitwW_getTestPar( void );
  545. int      __vf VE_nonlinfit_getTestDir( void );
  546. int      __vf VE_nonlinfitwW_getTestDir( void );
  547. int      __vf ME_nonlinfit_getTestDir( void );
  548. int      __vf ME_nonlinfitwW_getTestDir( void );
  549. void     __vf VE_nonlinfit_stop( void );
  550. void     __vf VE_nonlinfitwW_stop( void );
  551. void     __vf ME_nonlinfit_stop( void );
  552. void     __vf ME_nonlinfitwW_stop( void );
  553.  
  554. #ifdef __BORLANDC__
  555.     #pragma option -a-  /* avoid insertion of dummy bytes */
  556. #else   /* MS Visual C++ */
  557.     #pragma pack(push,1)
  558. #endif    /*  Borland or Microsoft */
  559. typedef struct VE_NONLINFITOPTIONS
  560. {
  561.       int        FigureOfMerit;  /*  0:least squares, 1:robust */
  562.              /* Convergence conditions: if the changes achieved
  563.                 in successive iterations are lower than any of the
  564.                 following values, this signals convergence. Set
  565.                 criteria to 0.0, if not applicable              */
  566.       extended   AbsTolChi,  /* absolute change of chi */
  567.                  FracTolChi, /* fractional change of chi */
  568.                  AbsTolPar,  /* absolute change of all parameters */
  569.                  FracTolPar; /* fractional change of all parameters */
  570.       unsigned   HowOftenFulfill; /* how often fulfill the above conditions? */
  571.       unsigned   LevelOfMethod;  /* 1: Levenberg-Marquardt method,
  572.                                     2: Downhill Simplex (Nelder and Mead) method,
  573.                                     3: both methods alternating;
  574.                                     add 4 to this in order to try
  575.                                        breaking out of local minima;
  576.                                     0: no fit, calculate only chi2 (and Covar) */
  577.       unsigned   LevMarIterations; /* max.number of successful iterations of LevMar */
  578.       unsigned   LevMarStarts; /* number of starts per LevMar run */
  579.       extended   LambdaStart,
  580.                  LambdaMin, LambdaMax,
  581.                  LambdaDiv, LambdaMul;    /* LevMar parameter lambda */
  582.       unsigned   DownhillIterations; /* max.number of successful iterations in Downhill */
  583.       extended   DownhillReflection,  /* re-shaping of the simplex */
  584.                  DownhillContraction,
  585.                  DownhillExpansion;
  586.       unsigned   TotalStarts;  /* max. number of LevMar/Downhill pairs */
  587.       eVector    UpperLimits;  /* impose upper limits on parameters */
  588.       eVector    LowerLimits;  /* impose lower limits on parameters */
  589.       void       (*Restrictions)(void);  /* user-defined editing of parameters */
  590. }  VE_NONLINFITOPTIONS;
  591.  
  592. void __vf VE_setNonlinfitOptions( VE_NONLINFITOPTIONS *Options );
  593. void __vf VE_getNonlinfitOptions( VE_NONLINFITOPTIONS *Options );
  594.  
  595. typedef struct VE_EXPERIMENT
  596. {
  597.     eVector    X, Y, InvVar;
  598.     ui         size;
  599.     extended   WeightOfExperiment;
  600.      /* InvVar and WeightOfExperiment are needed only for the
  601.         weighted variants of the multifit functions */
  602. } VE_EXPERIMENT;
  603.  
  604. typedef struct ME_EXPERIMENT
  605. {
  606.     eVector      X, Y;
  607.     eMatrix      MZ, MInvVar;  /* here no compatibility with static matrices! */
  608.     unsigned     htZ, lenZ;
  609.     extended     WeightOfExperiment;
  610.      /* MInvVar and WeightOfExperiment are needed only for the
  611.         weighted variants of the multifit functions */
  612. } ME_EXPERIMENT;
  613. #ifdef __BORLANDC__
  614.     #pragma option -a.   /* restore default data packing  */
  615. #else   /* MS Visual C++ */
  616.     #pragma pack(pop)
  617. #endif
  618.  
  619.  
  620. void __vf VE_multiLinfit( eVector A, iVector AStatus, unsigned ma,
  621.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  622.                 void (*funcs)(eVector BasFuncs, extended x,
  623.                               unsigned nfuncs, unsigned iexperiment) );
  624. #define   VE_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  625.           VEmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  626. void __vf ME_multiLinfit( eVector A, iVector AStatus, unsigned ma,
  627.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  628.                 void (*funcs)(eVector BasFuncs, extended x, extended y,
  629.                               unsigned nfuncs, unsigned iexperiment) );
  630. #define   ME_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  631.           MEmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  632. extended __vf VE_multiNonlinfit( eVector A, iVector AStatus, unsigned npars,
  633.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  634.                 void (*modelfunc)(eVector YModel, eVector XModel,
  635.                                   ui size, unsigned iexperiment),
  636.                 void (*derivatives)(eVector dYdAi,eVector X, ui size,
  637.                                    unsigned ipar, unsigned iexperiment) );
  638.             /* returns figure-of-merit of best A. If you don't know the
  639.                partial derivatives, set derivatives=NULL */
  640. #define   VE_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  641.           VEmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  642. extended __vf ME_multiNonlinfit( eVector A, iVector AStatus, unsigned npars,
  643.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  644.                 void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ,
  645.                                   eVector X, eVector Y, unsigned iexperiment),
  646.                 void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  647.                                     eVector X, eVector Y, unsigned ipar,
  648.                                     unsigned iexperiment) );
  649. #define   ME_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  650.           MEmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  651.  
  652. void  __vf VE_multiNonlinfit_autoDeriv( eVector dYdAi, eVector X, ui size,
  653.                                        unsigned iexperiment, unsigned ipar );
  654. void  __vf VE_multiNonlinfitwW_autoDeriv( eVector dYdAi, eVector X, ui size,
  655.                                        unsigned iexperiment, unsigned ipar );
  656. void  __vf ME_multiNonlinfit_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  657.                                     eVector X, eVector Y,
  658.                                     unsigned ipar, unsigned iexperiment );
  659. void  __vf ME_multiNonlinfitwW_autoDeriv( eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  660.                                     eVector X, eVector Y,
  661.                                     unsigned ipar, unsigned iexperiment );
  662. extended __vf VE_multiNonlinfit_getChi2( void );
  663. extended __vf VE_multiNonlinfitwW_getChi2( void );
  664. extended __vf ME_multiNonlinfit_getChi2( void );
  665. extended __vf ME_multiNonlinfitwW_getChi2( void );
  666. void     __vf VE_multiNonlinfit_getBestA( eVector ABest );
  667. void     __vf VE_multiNonlinfitwW_getBestA( eVector ABest );
  668. void     __vf ME_multiNonlinfit_getBestA( eVector ABest );
  669. void     __vf ME_multiNonlinfitwW_getBestA( eVector ABest );
  670. unsigned __vf VE_multiNonlinfit_getTestRun( void );
  671. unsigned __vf VE_multiNonlinfitwW_getTestRun( void );
  672. unsigned __vf ME_multiNonlinfit_getTestRun( void );
  673. unsigned __vf ME_multiNonlinfitwW_getTestRun( void );
  674. unsigned __vf VE_multiNonlinfit_getTestPar( void );
  675. unsigned __vf VE_multiNonlinfitwW_getTestPar( void );
  676. unsigned __vf ME_multiNonlinfit_getTestPar( void );
  677. unsigned __vf ME_multiNonlinfitwW_getTestPar( void );
  678. int      __vf VE_multiNonlinfit_getTestDir( void );
  679. int      __vf VE_multiNonlinfitwW_getTestDir( void );
  680. int      __vf ME_multiNonlinfit_getTestDir( void );
  681. int      __vf ME_multiNonlinfitwW_getTestDir( void );
  682. void     __vf VE_multiNonlinfit_stop( void );
  683. void     __vf VE_multiNonlinfitwW_stop( void );
  684. void     __vf ME_multiNonlinfit_stop( void );
  685. void     __vf ME_multiNonlinfitwW_stop( void );
  686.  
  687. /**************************  Input and Output  **************************/
  688.  
  689. #define ME_fprint( stream, MA, ht, len, linewidth ) \
  690.                     MEfprint( stream, MA[0], ht, len, linewidth )
  691. #define ME_print( MA, ht, len )  MEfprint( stdout, MA[0], ht, len, 80 )
  692. #define ME_cprint( MA, ht, len ) MEcprint( MA[0], ht, len )
  693.   /*  ME_print, ME_cprint usable only for DOS, EasyWin, and Win32 console applications! */
  694.  
  695. #define ME_write( str, MA, ht, len )   MEwrite( str, MA[0], ht, len )
  696. #define ME_read( MA, ht, len, str )    MEread( MA[0], ht, len, str )
  697. #define ME_setWriteFormat              VE_setWriteFormat
  698. #define ME_setWriteSeparate            VE_setNWriteSeparate
  699.                                    /* write and read in ascii format */
  700. #define ME_store( str, MA, ht, len ) \
  701.                            VE_store( str, MA[0], ((ui) (len))*(ht) );
  702. #define ME_recall( MA, ht, len, str) \
  703.                            VE_recall( MA[0], ((ui) (len))*(ht), str);
  704.                                   /* store and recall in binary format */
  705.  
  706.  
  707. /*************************************************************************
  708.  * Here are now the actual declarations of the functions used internally.*
  709.  * These declarations may change in future versions of MatrixLib!        *
  710.  * You should not care too much about them, except in the case you need  *
  711.  * the actual address of a run-time function (see above). Under all      *
  712.  * "normal" circumstances, use only the names defined above in the       *
  713.  * macro section!                                                        *
  714.  *************************************************************************/
  715.  
  716. extended _VFAR * MEPelement( ePMatrix X, unsigned ht, unsigned len,
  717.                              unsigned m, unsigned n );
  718.                   /* pointer is normalized in memory model HUGE */
  719.  
  720. #define MEequ0( MA, ht, len )            VE_equ0( MA, ((ui)ht)*len )
  721. void   __vf  MEequ1( ePMatrix MA, unsigned len );  /* identity matrix */
  722. void   __vf  MEouterprod( ePMatrix MA, eVector X,  eVector Y,
  723.                           unsigned ht, unsigned len );
  724.  
  725. void   __vf  MERow_equC( ePMatrix MA, unsigned ht, unsigned len,
  726.                          unsigned iRow, extended C );
  727. void   __vf  MECol_equC( ePMatrix MA, unsigned ht, unsigned len,
  728.                          unsigned iCol, extended C );
  729. void   __vf  MEDia_equC( ePMatrix MA, unsigned len, extended C );
  730.  
  731. void   __vf  MERow_equV( ePMatrix MA, unsigned ht, unsigned len,
  732.                          unsigned iRow, eVector X );
  733. void   __vf  MECol_equV( ePMatrix MA, unsigned ht, unsigned len,
  734.                          unsigned iCol, eVector X );
  735. void   __vf  MEDia_equV( ePMatrix MA, unsigned len, eVector X );
  736.  
  737. #define MEequM( MB, MA, ht, len )  VE_equV( MB, MA, (ui)(ht)*(len) )
  738. void   __vf  MEUequL( ePMatrix MA, unsigned len );
  739. void   __vf  MELequU( ePMatrix MA, unsigned len );
  740.  
  741. void   __vf  MEHanning( ePMatrix MA, unsigned ht, unsigned len );
  742. void   __vf  MEParzen(  ePMatrix MA, unsigned ht, unsigned len );
  743. void   __vf  MEWelch(   ePMatrix MA, unsigned ht, unsigned len );
  744.  
  745. /********  Extracting a submatrix and copying a submatrix back  *********/
  746.  
  747. void  __vf  MEsubmatrix( ePMatrix MSub,
  748.                           unsigned subHt,  unsigned subLen,
  749.                           ePMatrix MSrce,
  750.                           unsigned srceHt,  unsigned srceLen,
  751.                           unsigned firstRowInCol,  unsigned sampInCol,
  752.                           unsigned firstColInRow,  unsigned sampInRow );
  753.  
  754. void  __vf  MEsubmatrix_equM( ePMatrix MDest,
  755.                                unsigned destHt,     unsigned destLen,
  756.                                unsigned firstRowInCol,  unsigned sampInCol,
  757.                                unsigned firstColInRow,  unsigned sampInRow,
  758.                                ePMatrix MSrce,
  759.                                unsigned srceHt,     unsigned srceLen );
  760.  
  761.  
  762. /*****   Extracting a single row or a single column or the diagonal  *****
  763.  *       and storing it into a vector                                    */
  764.  
  765. void __vf MERow_extract( eVector Y, ePMatrix MA, unsigned ht, unsigned len,
  766.                            unsigned iRow );
  767. void __vf MECol_extract( eVector Y, ePMatrix MA, unsigned ht, unsigned len,
  768.                            unsigned iCol );
  769. void __vf MEDia_extract( eVector Y, ePMatrix MA, unsigned len );
  770.  
  771.  
  772. /*****************    Basic arithmetic operations ***********************
  773.      performed on one single row,  or one single column of any matrix,
  774.      or on the diagonal of a square matrix                              */
  775.  
  776. void   __vf  MERow_addC( ePMatrix MA, unsigned ht, unsigned len,
  777.                          unsigned iRow, extended C );
  778. void   __vf  MECol_addC( ePMatrix MA, unsigned ht, unsigned len,
  779.                          unsigned iCol, extended C );
  780. void   __vf  MEDia_addC( ePMatrix MA, unsigned len, extended C );
  781.  
  782. void   __vf  MERow_subC( ePMatrix MA, unsigned ht, unsigned len,
  783.                          unsigned iRow, extended C );
  784. void   __vf  MECol_subC( ePMatrix MA, unsigned ht, unsigned len,
  785.                          unsigned iCol, extended C );
  786. void   __vf  MEDia_subC( ePMatrix MA, unsigned len, extended C );
  787.  
  788. void   __vf  MERow_addV( ePMatrix MA, unsigned ht, unsigned len,
  789.                          unsigned iRow, eVector X );
  790. void   __vf  MECol_addV( ePMatrix MA, unsigned ht, unsigned len,
  791.                          unsigned iCol, eVector X );
  792. void   __vf  MEDia_addV( ePMatrix MA, unsigned len, eVector X );
  793.  
  794. void   __vf  MERow_subV( ePMatrix MA, unsigned ht, unsigned len,
  795.                          unsigned iRow, eVector X );
  796. void   __vf  MECol_subV( ePMatrix MA, unsigned ht, unsigned len,
  797.                          unsigned iCol, eVector X );
  798. void   __vf  MEDia_subV( ePMatrix MA, unsigned len, eVector X );
  799.  
  800. void   __vf  MERow_subrC( ePMatrix MA, unsigned ht, unsigned len,
  801.                          unsigned iRow, extended C );
  802. void   __vf  MECol_subrC( ePMatrix MA, unsigned ht, unsigned len,
  803.                          unsigned iCol, extended C );
  804. void   __vf  MEDia_subrC( ePMatrix MA, unsigned len, extended C );
  805.  
  806. void   __vf  MERow_subrV( ePMatrix MA, unsigned ht, unsigned len,
  807.                          unsigned iRow, eVector X );
  808. void   __vf  MECol_subrV( ePMatrix MA, unsigned ht, unsigned len,
  809.                          unsigned iCol, eVector X );
  810. void   __vf  MEDia_subrV( ePMatrix MA, unsigned len, eVector X );
  811.  
  812. void   __vf  MERow_mulC( ePMatrix MA, unsigned ht, unsigned len,
  813.                          unsigned iRow, extended C );
  814. void   __vf  MECol_mulC( ePMatrix MA, unsigned ht, unsigned len,
  815.                          unsigned iCol, extended C );
  816. void   __vf  MEDia_mulC( ePMatrix MA, unsigned len, extended C );
  817.  
  818. void   __vf  MERow_mulV( ePMatrix MA, unsigned ht, unsigned len,
  819.                          unsigned iRow, eVector X );
  820. void   __vf  MECol_mulV( ePMatrix MA, unsigned ht, unsigned len,
  821.                          unsigned iCol, eVector X );
  822. void   __vf  MEDia_mulV( ePMatrix MA, unsigned len, eVector X );
  823.  
  824. void   __vf  MERow_divC( ePMatrix MA, unsigned ht, unsigned len,
  825.                          unsigned iRow, extended C );
  826. void   __vf  MECol_divC( ePMatrix MA, unsigned ht, unsigned len,
  827.                          unsigned iCol, extended C );
  828. void   __vf  MEDia_divC( ePMatrix MA, unsigned len, extended C );
  829.  
  830. void   __vf  MERow_divV( ePMatrix MA, unsigned ht, unsigned len,
  831.                          unsigned iRow, eVector X );
  832. void   __vf  MECol_divV( ePMatrix MA, unsigned ht, unsigned len,
  833.                          unsigned iCol, eVector X );
  834. void   __vf  MEDia_divV( ePMatrix MA, unsigned len, eVector X );
  835.  
  836. void   __vf  MERow_divrC( ePMatrix MA, unsigned ht, unsigned len,
  837.                          unsigned iRow, extended C );
  838. void   __vf  MECol_divrC( ePMatrix MA, unsigned ht, unsigned len,
  839.                          unsigned iCol, extended C );
  840. void   __vf  MEDia_divrC( ePMatrix MA, unsigned len, extended C );
  841.  
  842. void   __vf  MERow_divrV( ePMatrix MA, unsigned ht, unsigned len,
  843.                          unsigned iRow, eVector X );
  844. void   __vf  MECol_divrV( ePMatrix MA, unsigned ht, unsigned len,
  845.                          unsigned iCol, eVector X );
  846. void   __vf  MEDia_divrV( ePMatrix MA, unsigned len, eVector X );
  847.  
  848.  
  849. /******  One-dimensional vector operations **********************
  850.          performed along all rows or all columns simultaneously,
  851.          or along the diagonal of a square matrix                */
  852.  
  853. void  __vf  MERows_max( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  854. void  __vf  MECols_max( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  855. extended __vf  MEDia_max(  ePMatrix MA, unsigned len );
  856. void  __vf  MERows_min( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  857. void  __vf  MECols_min( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  858. extended __vf  MEDia_min(  ePMatrix MA, unsigned len );
  859.  
  860. void  __vf  MERows_absmax( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  861. void  __vf  MECols_absmax( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  862. extended __vf  MEDia_absmax(  ePMatrix MA, unsigned len );
  863. void  __vf  MERows_absmin( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  864. void  __vf  MECols_absmin( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  865. extended __vf  MEDia_absmin(  ePMatrix MA, unsigned len );
  866.  
  867. void  __vf  MERows_sum( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  868. void  __vf  MECols_sum( eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  869. extended __vf  MEDia_sum(  ePMatrix MA, unsigned len );
  870. void  __vf  MERows_prod(eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  871. void  __vf  MECols_prod(eVector Y, ePMatrix MA, unsigned ht, unsigned len );
  872. extended __vf  MEDia_prod( ePMatrix MA, unsigned len );
  873.  
  874. void  __vf  MERows_runsum( ePMatrix MA, unsigned ht, unsigned len );
  875. void  __vf  MECols_runsum( ePMatrix MA, unsigned ht, unsigned len );
  876. void  __vf  MERows_runprod( ePMatrix MA, unsigned ht, unsigned len );
  877. void  __vf  MECols_runprod( ePMatrix MA, unsigned ht, unsigned len );
  878.  
  879. void  __vf  MERows_rotate( ePMatrix MA, unsigned ht, unsigned len, int pos );
  880. void  __vf  MECols_rotate( ePMatrix MA, unsigned ht, unsigned len, int pos );
  881. void  __vf  MERows_reflect( ePMatrix MA, unsigned ht, unsigned len );
  882. void  __vf  MECols_reflect( ePMatrix MA, unsigned ht, unsigned len );
  883.  
  884. /********  Operations involving two rows or two colums of one matrix  *****/
  885.  
  886. void   __vf  MERows_exchange( ePMatrix MA, unsigned ht, unsigned len,
  887.                               unsigned i1, unsigned i2 );
  888. void   __vf  MECols_exchange( ePMatrix MA, unsigned ht, unsigned len,
  889.                               unsigned i1, unsigned i2 );
  890.  
  891. void   __vf  MERows_add( ePMatrix MA, unsigned ht, unsigned len,
  892.                           unsigned destRow, unsigned sourceRow );
  893. void   __vf  MECols_add( ePMatrix MA, unsigned ht, unsigned len,
  894.                           unsigned destCol, unsigned sourceCol );
  895.  
  896. void   __vf  MERows_sub( ePMatrix MA, unsigned ht, unsigned len,
  897.                           unsigned destRow, unsigned sourceRow );
  898. void   __vf  MECols_sub( ePMatrix MA, unsigned ht, unsigned len,
  899.                           unsigned destCol, unsigned sourceCol );
  900.  
  901. void   __vf  MERows_Cadd( ePMatrix MA, unsigned ht, unsigned len,
  902.                            unsigned destRow, unsigned sourceRow, extended C );
  903. void   __vf  MECols_Cadd( ePMatrix MA, unsigned ht, unsigned len,
  904.                            unsigned destCol, unsigned sourceCol, extended C );
  905.  
  906. void   __vf  MERows_lincomb( ePMatrix MA, unsigned ht, unsigned len,
  907.                               unsigned destRow,  extended  destC,
  908.                               unsigned srceRow,  extended  srceC );
  909. void   __vf  MECols_lincomb( ePMatrix MA, unsigned ht, unsigned len,
  910.                               unsigned destCol,  extended  destC,
  911.                               unsigned srceCol,  extended  srceC );
  912.  
  913.  
  914. /*************************  Transposing a matrix **********************/
  915.  
  916. void  __vf  MEtranspose( ePMatrix MTr, ePMatrix MA,
  917.                           unsigned htTr, unsigned lenTr );
  918.  
  919.  
  920. /************************ Matrix Arithmetics *************************/
  921.  
  922. #define MEaddM( MC, MA, MB, htA, lenA ) \
  923.                  VE_addV( MC, MA, MB, ((ui)htA)*lenA )
  924. #define MEsubM( MC, MA, MB, htA, lenA ) \
  925.                  VE_subV( MC, MA, MB, ((ui)htA)*lenA )
  926. #define MEmulC( MB, MA, htA, lenA, C ) \
  927.                  VE_mulC( MB, MA, ((ui)htA)*lenA, C )
  928. #define MEdivC( MB, MA, htA, lenA, C ) \
  929.                  VE_divC( MB, MA, ((ui)htA)*lenA, C )
  930. #define MEsaddM( MC, MA, MB, htA, lenA, C ) \
  931.                  VEs_addV( MC, MA, MB, ((ui)htA)*lenA, C )
  932. #define MEssubM( MC, MA, MB, htA, lenA, C ) \
  933.                  VEs_subV( MC, MA, MB, ((ui)htA)*lenA, C )
  934. #define MElincomb( MC, MA, MB, htA, lenA, CA, CB ) \
  935.                  VE_lincomb( MC, MA, MB, ((ui)htA)*lenA, CA, CB )
  936. void  __vf  MEmulV( eVector Y, ePMatrix MA, eVector X,
  937.                     unsigned htA, unsigned lenA );
  938. void  __vf  VEmulM( eVector Y, eVector X, ePMatrix MA,
  939.                     unsigned sizX, unsigned lenA );
  940. void  __vf  MEmulM( ePMatrix MC, ePMatrix MA, ePMatrix MB,
  941.                       unsigned htA, unsigned lenA, unsigned lenB );
  942.  
  943.  
  944. /*************************  Linear Algebra    *****************************/
  945.  
  946. int    __vf  MELUdecompose( ePMatrix MLU,  uiVector Ind, ePMatrix MA,
  947.                             unsigned len );
  948.  
  949. void     __vf  MELUsolve( eVector X, ePMatrix MLU, eVector B, uiVector Ind,
  950.                           unsigned len );
  951. void     __vf  MELUinv( ePMatrix MInv, ePMatrix MLU, uiVector Ind,
  952.                         unsigned len );
  953. extended __vf  MELUdet( ePMatrix MLU, unsigned len, int permut );
  954. void     __vf  MELUimprove( eVector X, eVector B, ePMatrix MA, ePMatrix MLU,
  955.                             uiVector Ind, unsigned len );
  956.  
  957. int   __vf  MESVdecompose( ePMatrix MU, ePMatrix MV, eVector W, ePMatrix MA,
  958.                            unsigned htA, unsigned lenA );
  959. void  __vf  MESVsolve( eVector X, ePMatrix MU, ePMatrix MV, eVector W,
  960.                        eVector B, unsigned htU, unsigned lenU );
  961. void  __vf  MESVimprove(  eVector X, eVector B, ePMatrix MA,
  962.                        ePMatrix MU, ePMatrix MV, eVector W,
  963.                        unsigned htA, unsigned lenA );
  964.  
  965.           /*  functions using LUD or SVD     */
  966. int    __vf  MEsolve( eVector X, ePMatrix MA, eVector B, unsigned len );
  967.                   /* ret.value != 0 signals error */
  968. int    __vf  MEinv( ePMatrix MInv, ePMatrix MA, unsigned len );
  969.                  /* ret.value != 0 signals error */
  970. extended  __vf  MEdet( ePMatrix MA, unsigned len );
  971.  
  972. int    __vf  MEsolveBySVD( eVector X, ePMatrix MA, eVector B,
  973.                            unsigned ht, unsigned len );
  974.                  /*  ret.value != 0 signals failure */
  975. int    __vf  MEsafeSolve( eVector X, ePMatrix MA, eVector B, unsigned len );
  976.               /* ret.value 0: success via LUD; 1: success via SVD; -1: error */
  977.  
  978.        /*********  Eigenvalues and Eigenvectors  ********/
  979.  
  980. void __vf MEs_eigenvalues( eVector EigV, ePMatrix EigM, ePMatrix MA, unsigned len,
  981.                         int CalcEigenVec );
  982.  
  983. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  984.  
  985. void  __vf   MElFFT( ePMatrix MY, ePMatrix MX,
  986.                      unsigned ht, unsigned len, int dir );
  987. void  __vf   MElconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  988.                           ePMatrix MRsp, unsigned ht, unsigned len );
  989. void  __vf   MEldeconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  990.                             ePMatrix MRsp, unsigned ht, unsigned len );
  991. void  __vf   MElfilter( ePMatrix MY, ePMatrix MX, ePMatrix MFlt,
  992.                         unsigned ht, unsigned len );
  993. void  __vf   MElautocorr( ePMatrix MACorr, ePMatrix MX,
  994.                           unsigned ht, unsigned len );
  995. void  __vf   MElxcorr( ePMatrix MXCorr, ePMatrix MX, ePMatrix MY,
  996.                        unsigned ht, unsigned len );
  997. void  __vf   MElspectrum( ePMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  998.                           ePMatrix MX, unsigned htX, unsigned lenX,
  999.                           ePMatrix MWin );
  1000.  
  1001. void  __vf   MEsFFT( ePMatrix MY, ePMatrix MX,
  1002.                      unsigned ht, unsigned len, int dir );
  1003. void  __vf   MEsconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  1004.                           ePMatrix MRsp, unsigned ht, unsigned len );
  1005. void  __vf   MEsdeconvolve( ePMatrix MY, ePMatrix MFlt, ePMatrix MX,
  1006.                             ePMatrix MRsp, unsigned ht, unsigned len );
  1007. void  __vf   MEsfilter( ePMatrix MY, ePMatrix MX, ePMatrix MFlt,
  1008.                         unsigned ht, unsigned len );
  1009. void  __vf   MEsautocorr( ePMatrix MACorr, ePMatrix MX,
  1010.                           unsigned ht, unsigned len );
  1011. void  __vf   MEsxcorr( ePMatrix MXCorr, ePMatrix MX, ePMatrix MY,
  1012.                        unsigned ht, unsigned len );
  1013. void  __vf   MEsspectrum( ePMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  1014.                           ePMatrix MX, unsigned htX, unsigned lenX,
  1015.                           ePMatrix MWin );
  1016.  
  1017.       /***************  Data Fitting    ******************/
  1018.  
  1019. void __vf VEpolyfitwW( eVector A, ePMatrix Covar, unsigned deg,
  1020.                         eVector X, eVector Y, eVector InvVar, ui sizex );
  1021. void __vf VElinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  1022.                     eVector X, eVector Y, eVector InvVar, ui sizex,
  1023.                     void (*funcs)(eVector BasFuncs, extended x, unsigned nfuncs) );
  1024. extended __vf VEnonlinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  1025.                     eVector X, eVector Y, eVector InvVar, ui sizex,
  1026.                     void (*modelfunc)(eVector YModel, eVector X, ui size),
  1027.                     void (*derivatives)(eVector dYdAi, eVector X, ui size, unsigned i) );
  1028. void __vf MElinfit( eVector A, iVector AStatus, unsigned npars,
  1029.                     eVector X, eVector Y, ePMatrix MZ, unsigned htZ, unsigned lenZ,
  1030.                     void (*funcs)(eVector BasFuncs, extended x, extended y, unsigned nfuncs) );
  1031. extended __vf MEnonlinfit( eVector A, iVector AStatus, unsigned npars,
  1032.                     eVector X, eVector Y, ePMatrix MZ, unsigned htZ, unsigned lenZ,
  1033.                     void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ, eVector X, eVector Y ),
  1034.                     void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned i) );
  1035. void __vf MElinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  1036.                       eVector X, eVector Y, ePMatrix MZ, ePMatrix MInvVar, unsigned htZ, unsigned lenZ,
  1037.                       void (*funcs)(eVector BasFuncs, extended x, extended y, unsigned nfuncs) );
  1038. extended __vf MEnonlinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned npars,
  1039.                     eVector X, eVector Y, ePMatrix MZ, ePMatrix MInvVar, unsigned htZ, unsigned lenZ,
  1040.                     void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ, eVector X, eVector Y ),
  1041.                     void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ, eVector X, eVector Y, unsigned i) );
  1042.  
  1043. void __vf VEmultiLinfitwW( eVector A, ePMatrix Covar, iVector AStatus, unsigned ma,
  1044.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1045.                 void (*funcs)(eVector BasFuncs, extended x,
  1046.                               unsigned nfuncs, unsigned nexperiment) );
  1047. void __vf MEmultiLinfitwW( eVector A, ePMatrix Covar,
  1048.                 iVector AStatus, unsigned npars,
  1049.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1050.                 void (*funcs)(eVector BasFuncs, extended x, extended y,
  1051.                               unsigned nfuncs, unsigned nexperiment) );
  1052. extended __vf VEmultiNonlinfitwW( eVector A, ePMatrix Covar,
  1053.                 iVector AStatus, unsigned npars,
  1054.                 VE_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1055.                 void (*modelfunc)(eVector YModel, eVector X, ui size,
  1056.                                   unsigned iexperiment),
  1057.                 void (*derivatives)(eVector dYdAi, eVector X, ui size,
  1058.                                   unsigned ipar, unsigned iexperiment) );
  1059. extended __vf MEmultiNonlinfitwW( eVector A, ePMatrix Covar,
  1060.                 iVector AStatus, unsigned npars,
  1061.                 ME_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1062.                 void (*modelfunc)(eMatrix MZModel, unsigned htZ, unsigned lenZ,
  1063.                                   eVector X, eVector Y, unsigned iexperiment ),
  1064.                 void (*derivatives)(eMatrix dZdAi, unsigned htZ, unsigned lenZ,
  1065.                                     eVector X, eVector Y,
  1066.                                     unsigned ipar, unsigned iexperiment) );
  1067.  
  1068.       /*************  Input and Output  ****************/
  1069.  
  1070. void __vf MEfprint( FILE _VFAR *stream, ePMatrix MA, unsigned ht,
  1071.                     unsigned len, unsigned linewidth );
  1072. void __vf MEcprint( ePMatrix MA, unsigned ht, unsigned len );
  1073. void  __vf    MEwrite( FILE _VFAR *stream, ePMatrix X, unsigned ht, unsigned len  );
  1074. void  __vf    MEread( ePMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  1075. #define MEstore( str, MA, ht, len ) \
  1076.                            VE_store( str, MA, ((ui) (len))*(ht) );
  1077. #define MErecall( MA, ht, len, str) \
  1078.                            VE_recall( MA, ((ui) (len))*(ht), str);
  1079.  
  1080. #ifdef __cplusplus
  1081. }
  1082. #endif
  1083.  
  1084.  
  1085. #else   /* MSVC, Powersoft: ME_ functions are identical to MD_ */
  1086. #define ME_matrix   MD_matrix
  1087. #define ME_matrix0  MD_matrix0
  1088. #define ME_Pelement MD_Pelement
  1089. #define ME_element  MD_element
  1090. #define ME_equ0     MD_equ0
  1091. #define ME_equ1     MD_equ1
  1092. #define ME_outerprod MD_outerprod
  1093. #define ME_Row_equC  MD_Row_equC
  1094. #define ME_Col_equC  MD_col_equC
  1095. #define ME_Dia_equC  MD_Dia_equC
  1096. #define ME_Row_equV  MD_Row_equV
  1097. #define ME_Col_equV  MD_col_equV
  1098. #define ME_Dia_equV  MD_Dia_equV
  1099. #define ME_equM      MD_equM
  1100. #define ME_UequL     MD_UequL
  1101. #define ME_LequU     MD_LequU
  1102. #define M_EtoF( MF, ME, ht, len ) V_EtoF( MF[0], ME[0], ((ui)ht)*len )
  1103. #define M_FtoE( ME, MF, ht, len ) V_FtoE( ME[0], MF[0], ((ui)ht)*len )
  1104. #define M_EtoD( MD, ME, ht, len ) V_EtoD( MD[0], ME[0], ((ui)ht)*len )
  1105. #define M_DtoE( ME, MD, ht, len ) V_DtoE( ME[0], MD[0], ((ui)ht)*len )
  1106. #define ME_Hanning   MD_Hanning
  1107. #define ME_Parzen    MD_Parzen
  1108. #define ME_Welch     MD_Welch
  1109. #define ME_submatrix MD_submatrix
  1110. #define ME_submatrix_equM MD_submatrix_equM
  1111. #define ME_Row_extract MD_Row_extract
  1112. #define ME_Col_extract MD_Col_extract
  1113. #define ME_Dia_extract MD_Dia_extract
  1114. #define ME_Row_addC    MD_Row_addC
  1115. #define ME_Col_addC    MD_Col_addC
  1116. #define ME_Dia_addC    MD_Dia_addC
  1117. #define ME_Row_addV    MD_Row_addV
  1118. #define ME_Col_addV    MD_Col_addV
  1119. #define ME_Dia_addV    MD_Dia_addV
  1120. #define ME_Row_subC    MD_Row_subC
  1121. #define ME_Col_subC    MD_Col_subC
  1122. #define ME_Dia_subC    MD_Dia_subC
  1123. #define ME_Row_subV    MD_Row_subV
  1124. #define ME_Col_subV    MD_Col_subV
  1125. #define ME_Dia_subV    MD_Dia_subV
  1126. #define ME_Row_subrC   MD_Row_subrC
  1127. #define ME_Col_subrC   MD_Col_subrC
  1128. #define ME_Dia_subrC   MD_Dia_subrC
  1129. #define ME_Row_subrV   MD_Row_subrV
  1130. #define ME_Col_subrV   MD_Col_subrV
  1131. #define ME_Dia_subrV   MD_Dia_subrV
  1132. #define ME_Row_mulC    MD_Row_mulC
  1133. #define ME_Col_mulC    MD_Col_mulC
  1134. #define ME_Dia_mulC    MD_Dia_mulC
  1135. #define ME_Row_mulV    MD_Row_mulV
  1136. #define ME_Col_mulV    MD_Col_mulV
  1137. #define ME_Dia_divV    MD_Dia_divV
  1138. #define ME_Row_divC    MD_Row_divC
  1139. #define ME_Col_divC    MD_Col_divC
  1140. #define ME_Dia_divC    MD_Dia_divC
  1141. #define ME_Row_divV    MD_Row_divV
  1142. #define ME_Col_divV    MD_Col_divV
  1143. #define ME_Dia_divV    MD_Dia_divV
  1144. #define ME_Row_divrC   MD_Row_divrC
  1145. #define ME_Col_divrC   MD_Col_divrC
  1146. #define ME_Dia_divrC   MD_Dia_divrC
  1147. #define ME_Row_divrV   MD_Row_divrV
  1148. #define ME_Col_divrV   MD_Col_divrV
  1149. #define ME_Dia_divrV   MD_Dia_divrV
  1150. #define ME_Rows_max    MD_Cols_max
  1151. #define ME_Cols_max    MD_Rows_max
  1152. #define ME_Dia_max     MD_Dia_max
  1153. #define ME_Rows_min    MD_Cols_min
  1154. #define ME_Cols_min    MD_Rows_min
  1155. #define ME_Dia_min     MD_Dia_min
  1156. #define ME_Rows_absmax MD_Cols_absmax
  1157. #define ME_Cols_absmax MD_Rows_absmax
  1158. #define ME_Dia_absmax  MD_Dia_absmax
  1159. #define ME_Rows_absmin MD_Cols_absmin
  1160. #define ME_Cols_absmin MD_Rows_absmin
  1161. #define ME_Dia_absmin  MD_Dia_absmin
  1162. #define ME_Rows_sum    MD_Cols_sum
  1163. #define ME_Cols_sum    MD_Rows_sum
  1164. #define ME_Dia_sum     MD_Dia_sum
  1165. #define ME_Rows_prod   MD_Cols_prod
  1166. #define ME_Cols_prod   MD_Rows_prod
  1167. #define ME_Dia_prod    MD_Dia_prod
  1168. #define ME_Rows_runsum MD_Cols_runsum
  1169. #define ME_Cols_runsum MD_Rows_runsum
  1170. #define ME_Rows_runprod  MD_Cols_runprod
  1171. #define ME_Cols_runprod  MD_Rows_runprod
  1172. #define ME_Rows_rotate   MD_Cols_rotate
  1173. #define ME_Cols_rotate   MD_Rows_rotate
  1174. #define ME_Rows_reflect  MD_Cols_reflect
  1175. #define ME_Cols_reflect  MD_Rows_reflect
  1176. #define ME_Rows_exchange MD_Rows_exchange
  1177. #define ME_Cols_exchange MD_Cols_exchange
  1178. #define ME_Rows_add      MD_Cols_add
  1179. #define ME_Cols_add      MD_Rows_add
  1180. #define ME_Rows_sub      MD_Cols_sub
  1181. #define ME_Cols_sub      MD_Rows_sub
  1182. #define ME_Rows_Cadd     MD_Cols_Cadd
  1183. #define ME_Cols_Cadd     MD_Rows_Cadd
  1184. #define ME_Rows_lincomb  MD_Cols_lincomb
  1185. #define ME_Cols_lincomb  MD_Rows_lincomb
  1186. #define ME_transpose     MD_transpowe
  1187. #define ME_addM          MD_addM
  1188. #define ME_subM          MD_subM
  1189. #define ME_mulC          MD_mulC
  1190. #define ME_divC          MD_divC
  1191. #define MEs_addM         MDs_addM
  1192. #define MEs_subM         MDs_subM
  1193. #define ME_lincomb       MD_lincomb
  1194. #define ME_mulV          MD_mulV
  1195. #define VE_mulM          VD_mulM
  1196. #define ME_mulM          MD_mulM
  1197. #define ME_LUdecompose   MD_LUdecompose
  1198. #define ME_LUDresult     MD_LUDresult
  1199. #define ME_LUDsetEdit    MD_LUDsetEdit
  1200. #define ME_LUDgetEdit    MD_LUDgetEdit
  1201. #define ME_LUsolve       MD_LUsolve
  1202. #define ME_LUinv         MD_LUinv
  1203. #define ME_LUdet         MD_LUdet
  1204. #define ME_LUimprove     MD_LUimprove
  1205. #define ME_SVdecompose   MD_SVdecompose
  1206. #define ME_SVsolve       MD_SVsolve
  1207. #define ME_SVimprove     MD_SVimprove
  1208. #define ME_SVDsetEdit    MD_SVDsetEdit
  1209. #define ME_SVDgetEdit    MD_SVDgetEdit
  1210. #define ME_solve         MD_solve
  1211. #define ME_inv           MD_inv
  1212. #define ME_det           MD_det
  1213. #define ME_solveBySVD    MD_solveBySVD
  1214. #define ME_safeSolve     MD_safeSolve
  1215. #define MEsym_eigenvalues MDsym_eigenvalues
  1216. #define VE_getRspEdit    VD_getRspEdit 
  1217. #define VE_setRspEdit    VD_setRspEdit 
  1218. #define MEl_FFT          MDl_FFT
  1219. #define MEs_FFT          MDs_FFT
  1220. #define MEl_convolve     MDl_convolve
  1221. #define MEl_deconvolve   MDl_deconvolve
  1222. #define MEl_filter       MDl_filter
  1223. #define MEl_autocorr     MDl_autocorr
  1224. #define MEl_xcorr        MDl_xcorr
  1225. #define MEl_spectrum     MDl_spectrum
  1226. #define MEs_convolve     MDs_convolve
  1227. #define MEs_deconvolve   MDs_deconvolve
  1228. #define MEs_filter       MDs_filter
  1229. #define MEs_autocorr     MDs_autocorr
  1230. #define MEs_xcorr        MDs_xcorr
  1231. #define MEs_spectrum     MDs_spectrum
  1232. #define ME_FFT           MD_FFT
  1233. #define ME_convolve      MD_convolve
  1234. #define ME_deconvolve    MD_deconvolve
  1235. #define ME_filter        MD_filter
  1236. #define ME_autocorr      MD_autocorr
  1237. #define ME_xcorr         MD_xcorr
  1238. #define ME_spectrum      MD_spectrum
  1239. #define VE_polyfit       VD_polyfit
  1240. #define VE_polyfitwW     VD_polyfitwW
  1241. #define VE_linfit        VD_linfit
  1242. #define VE_linfitwW      VD_linfitwW
  1243. #define ME_linfit        MD_linfit
  1244. #define ME_linfitwW      MD_linfitwW
  1245. #define VE_setLinfitNeglect VD_setLinfitneglect
  1246. #define VE_getLinfitNeglect VD_getLinfitneglect
  1247. #define VE_nonlinfit     VD_nonlinfit
  1248. #define VE_nonlinfitwW   VD_nonlinfitwW
  1249. #define ME_nonlinfit     MD_nonlinfit
  1250. #define ME_nonlinfitwW   MD_nonlinfitwW
  1251. #define VE_nonlinfit_autoDeriv    VD_nonlinfit_autoDeriv
  1252. #define VE_nonlinfitwW_autoDeriv  VD_nonlinfitwW_autoDeriv
  1253. #define ME_nonlinfitwW_autoDeriv  MD_nonlinfitwW_autoDeriv
  1254. #define ME_nonlinfit_autoDeriv    MD_nonlinfit_autoDeriv
  1255. #define VE_nonlinfit_getChi2      VD_nonlinfit_getChi2
  1256. #define VE_nonlinfitwW_getChi2    VD_nonlinfitwW_getChi2
  1257. #define ME_nonlinfit_getChi2      MD_nonlinfit_getChi2
  1258. #define ME_nonlinfitwW_getChi2    MD_nonlinfitwW_getChi2
  1259. #define VE_nonlinfit_getBestA     VD_nonlinfit_getBestA
  1260. #define VE_nonlinfitwW_getBestA   VD_nonlinfitwW_getBestA
  1261. #define ME_nonlinfit_getBestA     MD_nonlinfit_getBestA
  1262. #define ME_nonlinfitwW_getBestA   MD_nonlinfitwW_getBestA
  1263. #define VE_nonlinfit_getTestRun   VD_nonlinfit_getTestRun
  1264. #define VE_nonlinfitwW_getTestRun VD_nonlinfitwW_getTestRun
  1265. #define ME_nonlinfit_getTestRun   MD_nonlinfit_getTestRun
  1266. #define ME_nonlinfitwW_getTestRun MD_nonlinfitwW_getTestRun
  1267. #define VE_nonlinfit_getTestPar   VD_nonlinfit_getTestPar
  1268. #define VE_nonlinfitwW_getTestPar VD_nonlinfitwW_getTestPar 
  1269. #define ME_nonlinfit_getTestPar   MD_nonlinfit_getTestPar
  1270. #define ME_nonlinfitwW_getTestPar MD_nonlinfitwW_getTestPar
  1271. #define VE_nonlinfit_getTestDir   VD_nonlinfit_getTestDir
  1272. #define VE_nonlinfitwW_getTestDir VD_nonlinfitwW_getTestDir
  1273. #define ME_nonlinfit_getTestDir   MD_nonlinfit_getTestDir
  1274. #define ME_nonlinfitwW_getTestDir MD_nonlinfitwW_getTestDir
  1275. #define VE_nonlinfit_stop         VD_nonlinfit_stop
  1276. #define VE_nonlinfitwW_stop       VD_nonlinfitwW_stop
  1277. #define ME_nonlinfit_stop         MD_nonlinfit_stop
  1278. #define ME_nonlinfitwW_stop       MD_nonlinfitwW_stop
  1279. #define VE_NONLINFITOPTIONS       VD_NONLINFITOPTIONS
  1280. #define VE_setNonlinfitOptions    VD_setNonlinfitOptions
  1281. #define VE_getNonlinfitOptions    VD_getNonlinfitOptions
  1282. #define VE_EXPERIMENT             VD_EXPERIMENT
  1283. #define ME_EXPERIMENT             MD_EXPERIMENT
  1284. #define VE_multiLinfit            VD_multiLinfit 
  1285. #define VE_multiLinfitwW          VD_multiLinfitwW
  1286. #define ME_multiLinfit            MD_multiLinfit
  1287. #define ME_multiLinfitwW          MD_multiLinfitwW 
  1288. #define VE_multiNonlinfit         VD_multiNonlinfit 
  1289. #define VE_multiNonlinfitwW       VD_multiNonlinfitwW
  1290. #define ME_multiNonlinfit         MD_multiNonlinfit
  1291. #define ME_multiNonlinfitwW       MD_multoNonlinfitwW
  1292. #define VE_multiNonlinfit_autoDeriv     VD_multiNonlinfit_autoDeriv
  1293. #define VE_multiNonlinfitwW_autoDeriv   VD_multiNonlinfitwW_autoDeriv 
  1294. #define ME_multiNonlinfit_autoDeriv     MD_multiNonlinfit_autoDeriv  
  1295. #define ME_multiNonlinfitwW_autoDeriv   MD_multiNonlinfitwW_autoDeriv
  1296. #define VE_multiNonlinfit_getChi2       VD_multiNonlinfit_getChi2
  1297. #define VE_multiNonlinfitwW_getChi2     VD_multiNonlinfitwW_getChi2 
  1298. #define ME_multiNonlinfit_getChi2       MD_multiNonlinfit_getChi2
  1299. #define ME_multiNonlinfitwW_getChi2     MD_multiNonlinfitwW_getChi2
  1300. #define VE_multiNonlinfit_getBestA      VD_multiNonlinfit_getBestA
  1301. #define VE_multiNonlinfitwW_getBestA    VD_multiNonlinfitwW_getBestA
  1302. #define ME_multiNonlinfit_getBestA      MD_multiNonlinfit_getBestA
  1303. #define ME_multiNonlinfitwW_getBestA    MD_multiNonlinfitwW_getBestA
  1304. #define VE_multiNonlinfit_getTestRun    VD_multiNonlinfit_getTestRun
  1305. #define VE_multiNonlinfitwW_getTestRun  VD_multiNonlinfitwW_getTestRun
  1306. #define ME_multiNonlinfit_getTestRun    MD_multiNonlinfit_getTestRun
  1307. #define ME_multiNonlinfitwW_getTestRun  MD_multiNonlinfitwW_getTestRun
  1308. #define VE_multiNonlinfit_getTestPar    VD_multiNonlinfit_getTestPar
  1309. #define VE_multiNonlinfitwW_getTestPar  VD_multiNonlinfitwW_getTestPar
  1310. #define ME_multiNonlinfit_getTestPar    MD_multiNonlinfit_getTestPar
  1311. #define ME_multiNonlinfitwW_getTestPar  MD_multiNonlinfitwW_getTestPar
  1312. #define VE_multiNonlinfit_getTestDir    VD_multiNonlinfit_getTestDir
  1313. #define VE_multiNonlinfitwW_getTestDir  VD_multiNonlinfitwW_getTestDir
  1314. #define ME_multiNonlinfit_getTestDir    MD_multiNonlinfit_getTestDir
  1315. #define ME_multiNonlinfitwW_getTestDir  MD_multiNonlinfitwW_getTestDir
  1316. #define VE_multiNonlinfit_stop          VD_multiNonlinfit_stop   
  1317. #define VE_multiNonlinfitwW_stop        VD_multiNonlinfitwW_stop
  1318. #define ME_multiNonlinfit_stop          MD_multiNonlinfit_stop
  1319. #define ME_multiNonlinfitwW_stop        MD_multiNonlinfitwW_stop
  1320. #define ME_fprint    MD_fprint
  1321. #define ME_print     MD_print
  1322. #define ME_cprint    MD_cprint
  1323. #define ME_write     MD_write
  1324. #define ME_read      MD_read
  1325. #define ME_setWriteFormat    VE_setWriteFormat
  1326. #define ME_setWriteSeparate  VE_setNWriteSeparate
  1327. #define ME_store     MD_store 
  1328. #define ME_recall    MD_recall
  1329.  
  1330. #endif  /* Borland, Microsoft, Powersoft  */
  1331.  
  1332. #endif /* __MESTD_H */
  1333.